// 请求封装（适配原有业务逻辑 + 统一 API 风格）
import axios from 'axios'
import { ElMessage, ElMessageBox } from 'element-plus'
import { useAuthStore } from '@/store/modules/auth'
import { useRouter } from 'vue-router'

// 创建 Axios 实例
const apiConfig = axios.create({
  baseURL: 'http://localhost:8090', // 直接写死后端地址
  timeout: 15000, // 超时时间15秒
  headers: {
    'Content-Type': 'application/json;charset=utf-8'
  }
})

// 请求拦截器
apiConfig.interceptors.request.use(
  (config) => {
    // 添加 Token
    const userStore = useAuthStore()
    if (userStore.token) {
      config.headers['Authorization'] = `Bearer ${userStore.token}`
    }
    // GET 参数编码（避免中文乱码）
    if (config.method === 'get' && config.params) {
      config.paramsSerializer = {
        serialize: (params) => {
          return Object.entries(params)
            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
            .join('&')
        }
      }
    }
    return config
  },
  (error) => {
    ElMessage.error('请求发送失败，请检查网络')
    return Promise.reject(error)
  }
)

// 响应拦截器
apiConfig.interceptors.response.use(
  (response) => {
    const res = response.data
    const router = useRouter()
    const userStore = useAuthStore()

    // 响应码处理（保留原有业务逻辑）
    switch (res.code) {
      case 200:
        return res
      case 401:
        ElMessageBox.confirm(
          '登录状态已过期，请重新登录',
          '登录失效',
          {
            confirmButtonText: '重新登录',
            cancelButtonText: '取消',
            type: 'warning',
            closeOnClickModal: false
          }
        ).then(() => {
          userStore.clearUserState()
          router.push('/login').catch(() => {})
        })
        return Promise.reject(new Error('登录已过期'))
      case 403:
        ElMessage.error('权限不足，无法操作')
        router.push('/layout/home').catch(() => {})
        return Promise.reject(new Error('权限不足'))
      case 500:
        ElMessage.error(res.msg || '服务器内部错误，请联系管理员')
        return Promise.reject(res)
      default:
        ElMessage.error(res.msg || '请求失败')
        return Promise.reject(res)
    }
  },
  (error) => {
    const message = error.message || '网络请求失败'
    ElMessage.error(message)
    return Promise.reject(error)
  }
)

// 封装统一 API 方法（与第一个封装样式一致）
const api = {
  /**
   * GET 请求
   * @param {string} url - 请求地址
   * @param {object} config - 请求配置（含 params 等）
   * @returns {Promise} - 响应结果
   */
  get(url, config) {
    return apiConfig.get(url, config)
  },

  /**
   * POST 请求
   * @param {string} url - 请求地址
   * @param {object} data - 请求体数据
   * @returns {Promise} - 响应结果
   */
  post(url, data, config) {
    return apiConfig.post(url, data, config)
  },

  /**
   * PUT 请求
   * @param {string} url - 请求地址
   * @param {object} data - 请求体数据
   * @returns {Promise} - 响应结果
   */
  put(url, data) {
    return apiConfig.put(url, data)
  },

  /**
   * DELETE 请求
   * @param {string} url - 请求地址
   * @param {object} config - 请求配置（含 params 等）
   * @returns {Promise} - 响应结果
   */
  delete(url, config) {
    return apiConfig.delete(url, config)
  },

  /**
   * 支持流式响应的 POST 方法（SSE）
   * @param {string} url - 请求地址
   * @param {object} data - 请求体数据
   * @returns {Promise<Response>} - fetch 响应对象
   */
  async postStream(url, data) {
    const userStore = useAuthStore()
    const token = userStore.token
    const headers = {
      'Content-Type': 'application/json;charset=utf-8'
    }

    if (token) {
      headers['Authorization'] = `Bearer ${token}`
    }

    try {
      // 拼接完整 URL
      const fullUrl = url.startsWith('http') ? url : `${apiConfig.defaults.baseURL}${url}`
      const response = await fetch(fullUrl, {
        method: 'POST',
        headers,
        body: JSON.stringify(data),
        signal: AbortSignal.timeout(10000) // 10秒超时
      })

      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`)
      }

      const contentType = response.headers.get('content-type')
      if (!contentType || !contentType.includes('text/event-stream')) {
        console.warn('警告：响应类型不是 text/event-stream，可能是普通 JSON')
      }

      return response
    } catch (error) {
      if (error.name === 'AbortError') {
        throw new Error('请求超时')
      }
      throw new Error(`请求失败：${error.message}`)
    }
  }
}

export default api